module unit_threaded.randomized.gen;

template from(string moduleName) {
    mixin("import from = " ~ moduleName ~ ";");
}

/* Return $(D true) if the passed $(D T) is a $(D Gen) struct.

A $(D Gen!T) is something that implicitly converts to $(D T), has a method
called $(D gen) that is accepting a $(D ref Random).

This module already brings Gens for numeric types, strings and ascii strings.

If a function needs to be benchmarked that has a parameter of custom type a
custom $(D Gen) is required.
*/
template isGen(T) {
    static if (is(T : Gen!(S), S...))
        enum isGen = true;
    else
        enum isGen = false;
}

///
unittest {
    static assert(!isGen!int);
    static assert(isGen!(Gen!(int, 0, 10)));
}

private template minimum(T) {
    import std.traits : isIntegral, isFloatingPoint, isSomeChar;

    static if (isIntegral!T || isSomeChar!T)
        enum minimum = T.min;
    else static if (isFloatingPoint!T)
        enum mininum = T.min_normal;
    else
        enum minimum = T.init;
}

private template maximum(T) {
    import std.traits : isNumeric;

    static if (isNumeric!T)
        enum maximum = T.max;
    else
        enum maximum = T.init;
}

/** A $(D Gen) type that generates numeric values between the values of the
template parameter $(D low) and $(D high).
*/
mixin template GenNumeric(T, T low, T high) {

    import std.random : Random;

    static assert(is(typeof(() { T[] res = frontLoaded(); })),
            "GenNumeric needs a function frontLoaded returning " ~ T.stringof ~ "[]");

    alias Value = T;

    T value;

    T gen(ref Random gen) {
        import std.random : uniform;

        static assert(low <= high);

        this.value = _index < frontLoaded.length ? frontLoaded[_index++]
            : uniform!("[]")(low, high, gen);

        return this.value;
    }

    ref T opCall() {
        return this.value;
    }

    void toString(scope void delegate(const(char)[]) sink) @trusted {
        import std.format : formattedWrite;
        import std.traits : isFloatingPoint;

        static if (isFloatingPoint!T) {
            static if (low == T.min_normal && high == T.max) {
                formattedWrite(sink, "'%s'", this.value);
            }
        } else static if (low == T.min && high == T.max) {
            formattedWrite(sink, "'%s'", this.value);
        } else {
            formattedWrite(sink, "'%s' low = '%s' high = '%s'", this.value, low, high);
        }
    }

    alias opCall this;

    private int _index;
}

/** A $(D Gen) type that generates numeric values between the values of the
template parameter $(D low) and $(D high).
*/
struct Gen(T, T low = minimum!T, T high = maximum!T)
        if (from!"std.traits".isIntegral!T) {
    private static T[] frontLoaded() @safe pure nothrow {
        import std.algorithm : filter;
        import std.array : array;

        T[] values = [0, 1, T.min, T.max];
        return values.filter!(a => a >= low && a <= high).array;
    }

    mixin GenNumeric!(T, low, high);
}

struct Gen(T, T low = 0, T high = 6.022E23)
        if (from!"std.traits".isFloatingPoint!T) {
    private static T[] frontLoaded() @safe pure nothrow {
        import std.algorithm : filter;
        import std.array : array;

        T[] values = [0, T.epsilon, T.min_normal, high];
        return values.filter!(a => a >= low && a <= high).array;
    }

    mixin GenNumeric!(T, low, high);
}

/** A $(D Gen) type that generates ASCII strings with a number of
characters that is between template parameter $(D low) and $(D high).

If $(D low) and $(D high) are very close together, this might return
values that are too short. They should differ by at least three for
char strings, one for wstrings, and zero for dstrings.
*/
struct Gen(T, size_t low = 0, size_t high = 32)
        if (from!"std.traits".isSomeString!T) {
    static const dchar[] charset;
    import std.random : Random, uniform;

    static immutable size_t numCharsInCharSet;
    alias Value = T;

    T value;
    static this() {
        import std.array : array;
        import std.uni : unicode;
        import std.format : format;
        import std.range : chain, iota;
        import std.algorithm : map, joiner;
        import std.conv : to;
        import std.utf : count;

        charset = chain( // \t and \n
                iota(0x09, 0x0B), // \r
                iota(0x0D, 0x0E), // ' ' through '~'; next is DEL
                iota(0x20, 0x7F), // Vulgar fractions, punctuation, letters with accents, Greek
                iota(0xA1,
                    0x377), // More Greek
                iota(0x37A, 0x37F), iota(0x384, 0x38A), iota(0x38C,
                    0x38C), iota(0x38E, 0x3A1), // Greek, Cyrillic, a bit of Armenian
                iota(0x3A3, 0x52F), // Armenian
                iota(0x531,
                    0x556), iota(0x559, 0x55F), // Arabic
                iota(0xFBD3, 0xFD3F),
                iota(0xFD50, 0xFD8F), iota(0xFD92, 0xFDC7), // Linear B, included because it's a high character set
                iota(0x1003C, 0x1003D),
                iota(0x1003F, 0x1004D), iota(0x10050, 0x1005D), iota(0x10080,
                    0x100FA), // Emoji
                iota(0x1F300, 0x1F6D4)).map!(a => cast(dchar) a).array;
        numCharsInCharSet = charset.length;
    }

    T gen(ref Random gen) {
        static assert(low <= high);
        import std.range.primitives : ElementType;
        import std.array : appender;
        import std.utf : encode;

        if (_index < frontLoaded.length) {
            value = frontLoaded[_index++];
            return value;
        }

        auto app = appender!T();
        app.reserve(high);
        size_t numElems = uniform!("[]")(low, high, gen);
        static if ((ElementType!T).sizeof == 1) {
            char[4] buf;
        } else static if ((ElementType!T).sizeof == 2) {
            wchar[2] buf;
        } else {
            dchar[1] buf;
        }

        size_t appLength = 0;
        while (appLength < numElems) {
            size_t charIndex = uniform!("[)")(0, charset.length, gen);
            auto len = encode(buf, charset[charIndex]);
            appLength += len;
            if (appLength > high)
                break;
            app.put(buf[0 .. len]);
        }

        this.value = app.data;
        return this.value;
    }

    ref T opCall() {
        return this.value;
    }

    void toString(scope void delegate(const(char)[]) sink) {
        import std.format : formattedWrite;

        static if (low == 0 && high == 32) {
            formattedWrite(sink, "'%s'", this.value);
        } else {
            formattedWrite(sink, "'%s' low = '%s' high = '%s'", this.value, low, high);
        }
    }

    alias opCall this;

private:

    int _index;

    T[] frontLoaded() @safe pure nothrow const {
        import std.algorithm : filter;
        import std.array : array;

        T[] values = ["", "a", "é"];
        return values.filter!(a => a.length >= low && a.length <= high).array;
    }
}

/// DITTO This random $(D string)s only consisting of ASCII character
struct GenASCIIString(size_t low = 1, size_t high = 32) {
    import std.random : Random;

    static string charSet;
    static immutable size_t numCharsInCharSet;

    string value;

    static this() {
        import std.array : array;
        import std.uni : unicode;
        import std.format : format;
        import std.range : chain, iota;
        import std.algorithm : map, joiner;
        import std.conv : to;
        import std.utf : byDchar, count;

        GenASCIIString!(low, high).charSet = to!string(chain(iota(0x21, 0x7E)
                .map!(a => to!char(cast(dchar) a)).array));

        GenASCIIString!(low, high).numCharsInCharSet = count(charSet);
    }

    string gen(ref Random gen) {
        import std.array : appender;
        import std.random : uniform;

        if (_index < frontLoaded.length) {
            value = frontLoaded[_index++];
            return value;
        }

        auto app = appender!string();
        app.reserve(high);
        size_t numElems = uniform!("[]")(low, high, gen);

        for (size_t i = 0; i < numElems; ++i) {
            size_t toSelect = uniform!("[)")(0, numCharsInCharSet, gen);
            app.put(charSet[toSelect]);
        }

        this.value = app.data;
        return this.value;
    }

    ref string opCall() {
        return this.value;
    }

    void toString(scope void delegate(const(char)[]) sink) {
        import std.format : formattedWrite;

        static if (low == 0 && high == 32) {
            formattedWrite(sink, "'%s'", this.value);
        } else {
            formattedWrite(sink, "'%s' low = '%s' high = '%s'", this.value, low, high);
        }
    }

    alias opCall this;

private:

    int _index;

    string[] frontLoaded() @safe pure nothrow const {
        return ["", "a"];
    }
}

struct Gen(T, size_t low = 1, size_t high = 1024)
        if (from!"std.range.primitives".isInputRange!T && !from!"std.traits".isSomeString!T) {

    import std.traits : Unqual, isIntegral, isFloatingPoint;
    import std.range : ElementType;
    import std.random : Random;

    alias Value = T;
    alias E = Unqual!(ElementType!T);

    T value;
    Gen!E elementGen;

    T gen(ref Random rnd) {
        value = _index < frontLoaded.length ? frontLoaded[_index++] : genArray(rnd);
        return value;
    }

    alias value this;

private:

    size_t _index;
    //these values are always generated
    T[] frontLoaded() @safe nothrow {
        T[] ret = [[]];
        return ret;
    }

    T genArray(ref Random rnd) {
        import std.array : appender;
        import std.random : uniform;

        immutable length = uniform(low, high, rnd);
        auto app = appender!T;
        app.reserve(length);
        foreach (i; 0 .. length) {
            app.put(elementGen.gen(rnd));
        }

        return app.data;
    }
}

static assert(isGen!(Gen!(int[])));

struct Gen(T) if (is(T == bool)) {
    import std.random : Random;

    bool value;
    alias value this;

    bool gen(ref Random rnd) @safe {
        import std.random : uniform;

        value = [false, true][uniform(0, 2, rnd)];
        return value;
    }
}

struct Gen(T, T low = minimum!T, T high = maximum!T)
        if (from!"std.traits".isSomeChar!T) {
    private static T[] frontLoaded() @safe pure nothrow {
        return [];
    }

    mixin GenNumeric!(T, low, high);
}

private template AggregateTuple(T...) {
    import unit_threaded.randomized.random : ParameterToGen;
    import std.meta : staticMap;

    alias AggregateTuple = staticMap!(ParameterToGen, T);
}

struct Gen(T) if (from!"std.traits".isAggregateType!T) {

    import std.traits : Fields;
    import std.random : Random;

    AggregateTuple!(Fields!T) generators;

    alias Value = T;
    Value value;

    T gen(ref Random rnd) @safe {
        static if (is(T == class))
            if (value is null)
                value = new T;

        foreach (i, ref g; generators) {
            value.tupleof[i] = g.gen(rnd);
        }

        return value;
    }

    inout(T) opCall() inout {
        return this.value;
    }

    alias opCall this;

}